
/**
 * DIY编辑器工具函数
 */

import { COMPONENT_TYPES, DEFAULT_COMPONENT_CONFIG, COMPONENT_META } from '../constants.js'

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
export function generateId() {
  return 'component_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)
}

/**
 * 创建组件对象
 * @param {string} type 组件类型
 * @param {Object} config 组件配置
 * @returns {Object} 组件对象
 */
export function createComponent(type, config = {}) {
  return {
    id: generateId(),
    type,
    name: COMPONENT_META[type]?.name || type,
    data: deepClone({
      ...DEFAULT_COMPONENT_CONFIG[type],
      ...config
    }),
    styles: {
      marginTop: 0,
      marginBottom: 0,
      marginLeft: 0,
      marginRight: 0
    }
  }
}

/**
 * 深度克隆对象
 * @param {Object} obj 要克隆的对象
 * @returns {Object} 克隆后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj
  if (obj instanceof Date) return new Date(obj.getTime())
  if (obj instanceof Array) return obj.map(item => deepClone(item))
  if (typeof obj === 'object') {
    const clonedObj = {}
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key])
      }
    }
    return clonedObj
  }
}

/**
 * 验证组件配置
 * @param {string} type 组件类型
 * @param {Object} config 组件配置
 * @returns {Object} 验证结果
 */
export function validateComponentConfig(type, config) {
  const defaultConfig = DEFAULT_COMPONENT_CONFIG[type]
  if (!defaultConfig) {
    return { valid: false, errors: [`未知的组件类型: ${type}`] }
  }

  const errors = []

  // 验证必填字段
  for (const key in defaultConfig) {
    if (defaultConfig.hasOwnProperty(key) && config[key] === undefined) {
      errors.push(`缺少必填字段: ${key}`)
    }
  }

  // 验证数据类型
  for (const key in config) {
    if (config.hasOwnProperty(key) && defaultConfig[key] !== undefined) {
      const expectedType = typeof defaultConfig[key]
      const actualType = typeof config[key]

      if (expectedType !== actualType) {
        errors.push(`字段 ${key} 类型错误: 期望 ${expectedType}, 实际 ${actualType}`)
      }
    }
  }

  return {
    valid: errors.length === 0,
    errors
  }
}

/**
 * 导出页面配置为JSON
 * @param {Object} pageConfig 页面配置
 * @param {Array} components 组件列表
 * @returns {string} JSON字符串
 */
export function exportToJson(pageConfig, components) {
  const data = {
    pageConfig,
    components,
    exportTime: new Date().toISOString()
  }
  return JSON.stringify(data, null, 2)
}

/**
 * 从JSON导入页面配置
 * @param {string} jsonString JSON字符串
 * @returns {Object} 页面配置和组件列表
 */
export function importFromJson(jsonString) {
  try {
    const data = JSON.parse(jsonString)
    return {
      success: true,
      pageConfig: data.pageConfig || {},
      components: data.components || []
    }
  } catch (error) {
    return {
      success: false,
      error: error.message
    }
  }
}

/**
 * 格式化图片URL
 * @param {string} url 图片URL
 * @param {string} baseUrl 基础URL
 * @returns {string} 格式化后的URL
 */
export function formatImageUrl(url, baseUrl = '') {
  if (!url) return ''

  // 如果已经是完整URL，直接返回
  if (url.startsWith('http://') || url.startsWith('https://')) {
    return url
  }

  // 如果是相对路径，添加基础URL
  if (url.startsWith('/')) {
    return baseUrl + url
  }

  // 其他情况，直接返回
  return url
}

/**
 * 格式化价格
 * @param {number} price 价格
 * @param {number} precision 小数位数
 * @returns {string} 格式化后的价格
 */
export function formatPrice(price, precision = 2) {
  if (isNaN(price)) return '0.00'
  return Number(price).toFixed(precision)
}

/**
 * 格式化日期
 * @param {Date|string|number} date 日期
 * @param {string} format 格式化字符串
 * @returns {string} 格式化后的日期
 */
export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
  if (!date) return ''

  const d = new Date(date)
  if (isNaN(d.getTime())) return ''

  const year = d.getFullYear()
  const month = String(d.getMonth() + 1).padStart(2, '0')
  const day = String(d.getDate()).padStart(2, '0')
  const hours = String(d.getHours()).padStart(2, '0')
  const minutes = String(d.getMinutes()).padStart(2, '0')
  const seconds = String(d.getSeconds()).padStart(2, '0')

  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds)
}

/**
 * 获取文件扩展名
 * @param {string} filename 文件名
 * @returns {string} 文件扩展名
 */
export function getFileExtension(filename) {
  if (!filename) return ''
  const lastDotIndex = filename.lastIndexOf('.')
  return lastDotIndex > -1 ? filename.substring(lastDotIndex + 1).toLowerCase() : ''
}

/**
 * 检查文件类型是否为图片
 * @param {string} filename 文件名
 * @returns {boolean} 是否为图片
 */
export function isImageFile(filename) {
  const imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']
  const extension = getFileExtension(filename)
  return imageExtensions.includes(extension)
}

/**
 * 检查文件大小是否超过限制
 * @param {number} size 文件大小（字节）
 * @param {number} maxSize 最大大小（MB）
 * @returns {boolean} 是否超过限制
 */
export function isFileSizeExceeded(size, maxSize) {
  return size > maxSize * 1024 * 1024
}

/**
 * 生成随机颜色
 * @returns {string} 随机颜色
 */
export function generateRandomColor() {
  return '#' + Math.floor(Math.random()*16777215).toString(16)
}

/**
 * 颜色转换为RGB
 * @param {string} hex 十六进制颜色
 * @returns {Object} RGB颜色对象
 */
export function hexToRgb(hex) {
  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
  return result ? {
    r: parseInt(result[1], 16),
    g: parseInt(result[2], 16),
    b: parseInt(result[3], 16)
  } : null
}

/**
 * RGB转换为十六进制
 * @param {number} r 红色值
 * @param {number} g 绿色值
 * @param {number} b 蓝色值
 * @returns {string} 十六进制颜色
 */
export function rgbToHex(r, g, b) {
  return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)
}

/**
 * 计算两点之间的距离
 * @param {number} x1 点1的x坐标
 * @param {number} y1 点1的y坐标
 * @param {number} x2 点2的x坐标
 * @param {number} y2 点2的y坐标
 * @returns {number} 两点之间的距离
 */
export function calculateDistance(x1, y1, x2, y2) {
  return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2))
}

/**
 * 防抖函数
 * @param {Function} fn 要防抖的函数
 * @param {number} delay 延迟时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export function debounce(fn, delay) {
  let timer = null
  return function (...args) {
    if (timer) clearTimeout(timer)
    timer = setTimeout(() => {
      fn.apply(this, args)
    }, delay)
  }
}

/**
 * 节流函数
 * @param {Function} fn 要节流的函数
 * @param {number} delay 延迟时间（毫秒）
 * @returns {Function} 节流后的函数
 */
export function throttle(fn, delay) {
  let lastTime = 0
  return function (...args) {
    const now = Date.now()
    if (now - lastTime >= delay) {
      fn.apply(this, args)
      lastTime = now
    }
  }
}
